/**
 * 缓存管理器
 * 统一管理应用的缓存功能
 */

const fs = require('fs');
const path = require('path');

class CacheManager {
    constructor(cacheDir = 'cache') {
        this.cacheDir = path.join(__dirname, '../../', cacheDir);
        this.ensureCacheDir();
    }

    /**
     * 确保缓存目录存在
     * @private
     */
    ensureCacheDir() {
        if (!fs.existsSync(this.cacheDir)) {
            fs.mkdirSync(this.cacheDir, { recursive: true });
        }
    }

    /**
     * 生成缓存键
     * @param {string} prefix - 前缀
     * @param {string} identifier - 标识符
     * @returns {string} 缓存键
     */
    generateCacheKey(prefix, identifier) {
        return `${prefix}_${identifier}`;
    }

    /**
     * 获取缓存文件路径
     * @param {string} cacheKey - 缓存键
     * @returns {string} 缓存文件路径
     */
    getCacheFilePath(cacheKey) {
        return path.join(this.cacheDir, `${cacheKey}.json`);
    }

    /**
     * 保存缓存
     * @param {string} cacheKey - 缓存键
     * @param {Object} data - 要缓存的数据
     * @returns {boolean} 是否保存成功
     */
    save(cacheKey, data) {
        try {
            const filePath = this.getCacheFilePath(cacheKey);
            const cacheData = {
                data: data,
                timestamp: Date.now(),
                version: '2.0.0'
            };
            
            fs.writeFileSync(filePath, JSON.stringify(cacheData, null, 2));
            return true;
        } catch (error) {
            console.error('保存缓存失败:', error);
            return false;
        }
    }

    /**
     * 加载缓存
     * @param {string} cacheKey - 缓存键
     * @returns {Object|null} 缓存数据
     */
    load(cacheKey) {
        try {
            const filePath = this.getCacheFilePath(cacheKey);
            
            if (!fs.existsSync(filePath)) {
                return null;
            }
            
            const cacheContent = fs.readFileSync(filePath, 'utf8');
            const cacheData = JSON.parse(cacheContent);
            
            return cacheData.data;
        } catch (error) {
            console.error('加载缓存失败:', error);
            return null;
        }
    }

    /**
     * 检查缓存是否存在
     * @param {string} cacheKey - 缓存键
     * @returns {boolean} 是否存在
     */
    exists(cacheKey) {
        const filePath = this.getCacheFilePath(cacheKey);
        return fs.existsSync(filePath);
    }

    /**
     * 删除缓存
     * @param {string} cacheKey - 缓存键
     * @returns {boolean} 是否删除成功
     */
    delete(cacheKey) {
        try {
            const filePath = this.getCacheFilePath(cacheKey);
            
            if (fs.existsSync(filePath)) {
                fs.unlinkSync(filePath);
            }
            
            return true;
        } catch (error) {
            console.error('删除缓存失败:', error);
            return false;
        }
    }

    /**
     * 清空所有缓存
     * @returns {boolean} 是否清空成功
     */
    clear() {
        try {
            const files = fs.readdirSync(this.cacheDir);
            
            files.forEach(file => {
                if (file.endsWith('.json')) {
                    fs.unlinkSync(path.join(this.cacheDir, file));
                }
            });
            
            return true;
        } catch (error) {
            console.error('清空缓存失败:', error);
            return false;
        }
    }

    /**
     * 获取缓存统计信息
     * @returns {Object} 缓存统计
     */
    getStats() {
        try {
            const files = fs.readdirSync(this.cacheDir);
            const cacheFiles = files.filter(file => file.endsWith('.json'));
            
            let totalSize = 0;
            cacheFiles.forEach(file => {
                const filePath = path.join(this.cacheDir, file);
                const stats = fs.statSync(filePath);
                totalSize += stats.size;
            });
            
            return {
                count: cacheFiles.length,
                totalSize: totalSize,
                files: cacheFiles
            };
        } catch (error) {
            console.error('获取缓存统计失败:', error);
            return { count: 0, totalSize: 0, files: [] };
        }
    }
}

module.exports = CacheManager;